home *** CD-ROM | disk | FTP | other *** search
/ Compendium Deluxe 2 / LSD and 17bit Compendium Deluxe - Volume II.iso / a / prog / misc / frefs11.lha / FetchRefs / Source / GenerateIndex / Lists.c < prev    next >
C/C++ Source or Header  |  1994-10-21  |  21KB  |  780 lines
  1. /**************************************************************************/
  2. /* Lists.c - all that's got to do with the lists, including building and  */
  3. /*           I/O.                                                         */
  4. /**************************************************************************/
  5.  
  6. #include "GenerateIndex.h"
  7.  
  8. struct Prefs Settings;
  9.  
  10. UBYTE DataName[108];
  11.  
  12. /// LoadData(STRPTR filename)
  13. void
  14. LoadData(STRPTR name)
  15. {
  16.     STRPTR filename;
  17.     struct Node node;
  18.     FILE *file;
  19.     struct List *currentfile;
  20.  
  21.     filename = name;
  22.     
  23.     if (!name)
  24.     {
  25.         if (rtFileRequest(DataFileReq, DataName,
  26.                           "Load file...",
  27.  
  28.                           TAG_END))
  29.             filename = JoinPath(DataFileReq->Dir, DataName);
  30.  
  31.         if (!filename)
  32.             return;
  33.     }
  34.     
  35.     if (file = fopen(filename, "r"))
  36.     {
  37.         while (fread(&node, sizeof(struct Node), 1, file) > 0)
  38.         {
  39.             if (node.ln_Type == 1)
  40.             {
  41.                 struct FileEntry *entry;
  42.  
  43.                 if (entry = AllocVec((LONG)node.ln_Succ, MEMF_CLEAR))
  44.                 {
  45.                     entry->node.ln_Type = node.ln_Type;
  46.                     entry->node.ln_Name = entry->Name;
  47.                     fread(entry->afternode, ((LONG)node.ln_Succ) - sizeof(struct Node), 1, file);
  48.                     NewList(currentfile = &entry->RefsList);
  49.  
  50.                     AddTail(&FileList, &entry->node);
  51.                 } else
  52.                     fseek(file, ((LONG)node.ln_Succ) - sizeof(struct Node), SEEK_CUR);
  53.             } else if (node.ln_Type == 2)
  54.             {
  55.                 struct RefsEntry *entry;
  56.  
  57.                 if (entry = AllocVec((LONG)node.ln_Succ, MEMF_CLEAR))
  58.                 {
  59.                     entry->node.ln_Type = node.ln_Type;
  60.                     entry->node.ln_Name = entry->Name;
  61.                     fread(entry->afternode, ((LONG)node.ln_Succ) - sizeof(struct Node), 1, file);
  62.  
  63.                     AddTail(currentfile, &entry->node);
  64.                 } else
  65.                     fseek(file, ((LONG)node.ln_Succ) - sizeof(struct Node), SEEK_CUR);
  66.             }
  67.         }
  68.         fclose(file);
  69.     }
  70.     if (!name)
  71.         FreeVec(filename);
  72. }
  73. ///
  74. /// SaveData(STRPTR filename)
  75. void
  76. SaveData(STRPTR name)
  77. {
  78.     STRPTR filename;
  79.     struct FileEntry *entry;
  80.     struct RefsEntry *refentry;
  81.     FILE *file;
  82.     void *copy;
  83.  
  84.     filename = name;
  85.     
  86.     if (!name)
  87.     {
  88.         if (rtFileRequest(DataFileReq, DataName,
  89.                           "Save as...",
  90.  
  91.                           RTFI_Flags,    FREQF_SAVE,
  92.                           TAG_END))
  93.             filename = JoinPath(DataFileReq->Dir, DataName);
  94.  
  95.         if (!filename)
  96.             return;
  97.     }
  98.  
  99.     entry = (struct FileEntry *)FileList.lh_Head;
  100.  
  101.     if (file = fopen(filename, "w"))
  102.     {
  103.         void *buf;
  104.  
  105.         /* Bigger buffer gives faster I/O */
  106.         if (buf = AllocVec(10 * 1024, NULL))
  107.             setvbuf(file, buf, _IOFBF, 10 * 1024);
  108.  
  109.         while (entry->node.ln_Succ)
  110.         {
  111.             int size;
  112.  
  113.             copy = entry->node.ln_Succ;
  114.             size = ((sizeof(struct FileEntry) + strlen(entry->node.ln_Name) + 1) + 1) & ~1;
  115.             entry->node.ln_Succ = (void *)size;
  116.             fwrite(entry, 1, size, file);
  117.             entry->node.ln_Succ = copy;
  118.  
  119.             refentry = entry->RefsList.lh_Head;
  120.             while (refentry->node.ln_Succ)
  121.             {
  122.                 copy = refentry->node.ln_Succ;
  123.                 size = ((sizeof(struct RefsEntry) + strlen(refentry->node.ln_Name) + 1) + 1) & ~1;
  124.                 refentry->node.ln_Succ = (void *)size;
  125.                 fwrite(refentry, 1, size, file);
  126.                 refentry->node.ln_Succ = copy;
  127.  
  128.                 refentry = refentry->node.ln_Succ;
  129.             }
  130.  
  131.             entry = entry->node.ln_Succ;
  132.         }
  133.         fclose(file);
  134.         FreeVec(buf);
  135.     }
  136.  
  137.     if (!name)
  138.         FreeVec(filename);
  139. }
  140. ///
  141.  
  142. /// IndexFileList(UBYTE *path, struct rtFileList *lst)
  143. LONG
  144. IndexFileList(UBYTE *path, struct rtFileList *lst)
  145. {
  146.     UBYTE *dir;
  147.  
  148.     if (!(dir = FullName(path)))
  149.         return(ERROR_NO_FREE_STORE);
  150.  
  151.     do
  152.     {
  153.         if (lst->StrLen == -1)
  154.             IndexRecursive(dir, lst->Name);
  155.         else
  156.             IndexFile(dir, lst->Name);
  157.     } while (lst = lst->Next);
  158.     FreeVec(dir);
  159. }
  160. ///
  161. /// IndexRecursive(UBYTE *path, UBYTE *dir)
  162. void
  163. IndexRecursive(UBYTE *path, UBYTE *dir)
  164. {
  165.     BPTR lock;
  166.     UBYTE *name;
  167.     struct FileInfoBlock *fib;
  168.  
  169.     fib = AllocDosObject(DOS_FIB, NULL);
  170.     name = JoinPath(path, dir);
  171.     lock = Lock(name, ACCESS_READ);
  172.  
  173.     Examine(lock, fib);
  174.     while (ExNext(lock, fib))
  175.     {
  176.         if (fib->fib_DirEntryType < 0)
  177.             IndexFile(name, fib->fib_FileName);
  178.         else if (Settings.Recursively)
  179.             IndexRecursive(name, fib->fib_FileName);
  180.     }
  181.     UnLock(lock);
  182.     FreeVec(name);
  183.     FreeDosObject(DOS_FIB, fib);
  184. }
  185. ///
  186. /// IndexFile(UBYTE *dir, UBYTE *filename)
  187. void
  188. IndexFile(UBYTE *dir, UBYTE *filename)
  189. {
  190.     UBYTE *name;
  191.  
  192.     if (name = JoinPath(dir, filename))
  193.     {
  194.         switch (FileType(name))
  195.         {
  196.             case FILE_AUTODOC:  ADocToList(name);   break;
  197.             case FILE_C:        CToList(name);      break;
  198.             case FILE_E:        EToList(name);      break;
  199.             case FILE_ASM:      AsmToList(name);    break;
  200.         }
  201.         FreeVec(name);
  202.     }
  203. }
  204. ///
  205.  
  206. /// FileType(STRPTR filename)
  207. LONG FileType(STRPTR filename)
  208. {
  209.     BPTR file;
  210.     STRPTR buf;
  211.     LONG type = FILE_UNKNOWN;
  212.     
  213.     if (buf = AllocVec(2048, NULL))
  214.     {
  215.         if (file = Open(filename, MODE_OLDFILE))
  216.         {
  217.             LONG len;
  218.             
  219.             len = Read(file, buf, 2047);
  220.             Close(file);
  221.  
  222.             if (len > 0)
  223.             {
  224.                 buf[len] = 0;
  225.  
  226.                 if (strstr(buf, "TABLE OF CONTENTS"))
  227.                     type = FILE_AUTODOC;
  228.  
  229.                 else if (strstr(buf, "#if"))
  230.                     type = FILE_C;
  231.                 else if (strstr(buf, "#define"))
  232.                     type = FILE_C;
  233.  
  234.                 else if (strstr(buf, "\n(---) OBJECT"))
  235.                     type = FILE_E;
  236.                 else if (strstr(buf, "\nCONST"))
  237.                     type = FILE_E;
  238.                 else if (strstr(buf, "\nPROC"))
  239.                     type = FILE_E;
  240.  
  241.                 else if (strstr(buf, "IFND"))
  242.                     type = FILE_ASM;
  243.                 else if (strstr(buf, "EQU"))
  244.                     type = FILE_ASM;
  245.                 else if (strstr(buf, "STRUCTURE"))
  246.                     type = FILE_ASM;
  247.                 else if (strstr(buf, "MACRO"))
  248.                     type = FILE_ASM;
  249.                 else if (strstr(buf, "BITDEF"))
  250.                     type = FILE_ASM;
  251.                 else
  252.                     type = (Settings.UnknownFiles == UNKNOWN_ARE_AUTODOCS) ? FILE_AUTODOC : FILE_UNKNOWN;
  253.  
  254.             }
  255.         }
  256.  
  257.         FreeVec(buf);
  258.     }
  259.     return(type);
  260. }
  261. ///
  262.  
  263. /// FullName(STRPTR path)
  264. STRPTR
  265. FullName(STRPTR path)
  266. {
  267.     UBYTE *dir;
  268.  
  269.     dir = path;
  270.     while (*dir)
  271.         if (*dir++ == ':')
  272.         {
  273.             if (dir = AllocVec(strlen(path) + 1, NULL))
  274.                 strcpy(dir, path);
  275.             return(dir);
  276.         }
  277.  
  278.     if (dir = AllocVec(512, NULL))
  279.     {
  280.         BPTR lok;
  281.  
  282.         if (lok = Lock(path, ACCESS_READ))
  283.         {
  284.             NameFromLock(lok, dir, 512);
  285.             UnLock(lok);
  286.         }
  287.     }
  288.     return(dir);
  289. }
  290. ///
  291. /// JoinPath(UBYTE *dir, UBYTE *name)
  292. UBYTE *
  293. JoinPath(UBYTE *dir, UBYTE *name)
  294. {
  295.     LONG len;
  296.     UBYTE *both;
  297.  
  298.     len = strlen(dir) + 1 + strlen(name) + 1;
  299.  
  300.     if (both = AllocVec(len, NULL))
  301.     {
  302.         strcpy(both, dir);
  303.         if (name[0])
  304.             AddPart(both, name, len);
  305.     }
  306.     return(both);
  307. }
  308. ///
  309.  
  310. /// ADocToList(UBYTE *filename)
  311. void
  312. ADocToList(UBYTE *filename)
  313. {
  314.     FILE *file;
  315.     UBYTE buf[256];
  316.     struct FileEntry *list;
  317.     LONG nextff = 0;
  318.  
  319.     if (!Settings.AutoDocPrf.Active)
  320.         return;
  321.     
  322.     if (!(list = AddFileToList(filename)))
  323.         return;
  324.  
  325.     if (file = fopen(filename, "r"))
  326.     {    
  327.         while (fgets(buf, 256, file))
  328.         {
  329.             STRPTR left, right;
  330.             LONG buflen = strlen(buf), rightlen = 0;
  331.  
  332.             /* Always know where the next "reference ends" mark is */
  333.             if (ftell(file) > nextff)
  334.             {
  335.                 LONG ch, wasat = ftell(file);
  336.  
  337.                 for (ch = 0; ch != '\f' && ch != EOF; ch = getc(file))
  338.                     ;
  339.  
  340.                 nextff = ftell(file) - 1;
  341.                 fseek(file, wasat, SEEK_SET);
  342.             }
  343.  
  344.             /* Skip formfeeds and remove trailing '\n' */
  345.             for (left = buf; *left == '\f'; left++) ;
  346.             buf[buflen - 1] = ' ';
  347.  
  348.             /* Set 'right' to point to the start of the last word of the line */
  349.             right = buf + buflen;
  350.             while ((right[-1] == ' ') || (right[-1] == '\t'))
  351.                 *--right = 0;
  352.             while ((right[-1] != ' ') && (right[-1] != '\t'))
  353.                 right--, rightlen++;
  354.  
  355.             /* Only one word on this line? */
  356.             if (right <= left)
  357.                 continue;
  358.  
  359.             /* Did the line start and end with two words that are alike? */
  360.             if (strncmp(left, right, rightlen) == 0)
  361.             {
  362.                 LONG start = ftell(file) - buflen + (left - buf);
  363.                 
  364.                 /* Set 'right' to point to the start of the name */
  365.                 right = buf + strlen(buf);
  366.                 while (IsAlphaNum(right[-1]))
  367.                    right--;
  368.  
  369.                 AddRefToList(list, start, nextff - start, 0, right);
  370.             }
  371.         }
  372.         fclose(file);
  373.     }
  374.  
  375.     if ((!Settings.KeepEmpty) && IsListEmpty(&list->RefsList))
  376.     {
  377.         Remove(&list->node);
  378.         FreeVec(list);
  379.     }
  380. }
  381. ///
  382. /// CToList(UBYTE *filename)
  383. void
  384. CToList(UBYTE *filename)
  385. {
  386.     FILE *file;
  387.     struct FileEntry *list;
  388.     UBYTE buf[256], structname[128], namecopy[128], *c;
  389.     LONG lastlastend = 0, lastend = 0, offset = 0;
  390.     LONG lineoffset = 0, lastlineoffset = 0, totallines = 0;
  391.     BYTE inastruct = FALSE;
  392.  
  393.     if (!Settings.CPrf.Active)
  394.         return;
  395.     
  396.     if (!(list = AddFileToList(filename)))
  397.         return;
  398.  
  399.     if ((Settings.CPrf.Define || Settings.CPrf.Struct || Settings.CPrf.Typedef) && (file = fopen(filename, "r")))
  400.     {    
  401.         namecopy[0] = 0;
  402.         while (fgets(buf, 256, file) != NULL)
  403.         {
  404.             lineoffset++;
  405.             totallines++;
  406.  
  407.             if (Settings.CPrf.Struct)
  408.             {
  409.                 if ((c = strstr(buf, "struct")) || (c = strstr(buf, "union")))
  410.                 {
  411.                     c += (*c == 's') ? 6 : 5; /* Skip past keyword */
  412.                     c = SetSName(structname, c);
  413.  
  414.                     /* Find '{' */                     /*}*/
  415.                     {
  416.                         while (*c == ' ' || *c == '\t' || *c == '\n' || *c == '\f')
  417.                             c++;
  418.  
  419.                         /* Search forward if it's not on the current line */
  420.                         if (*c == 0) {
  421.                             short ch = ' ';
  422.                             LONG savpos = ftell(file);
  423.                             while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\f')
  424.                                 ch = getc(file);
  425.                             c[0] = ch;
  426.                             fseek(file, savpos, SEEK_SET);
  427.                         }
  428.                     }
  429.  
  430.                     /* If an actual definition was found */
  431.                     if (*c == '{' && structname[0])
  432.                     {
  433.                         inastruct = TRUE;
  434.  
  435.                         /* Now we can write the last one */
  436.                         if (namecopy[0])
  437.                         {
  438.                             AddRefToList(list, lastlastend, offset - lastlastend, lastlineoffset, namecopy);
  439.                             lastlastend = lastend;
  440.                         }
  441.                         strcpy(namecopy, structname);
  442.                         lastlineoffset = lineoffset;
  443.                     }
  444.                 }
  445.  
  446.                 offset = ftell(file);
  447.  
  448.                 /* Reached the end of a definition */
  449.                 if (inastruct && strstr(buf, "}"))
  450.                 {
  451.                     inastruct = FALSE;
  452.                     lastend = offset;
  453.                     lineoffset = 0;
  454.                 }
  455.             }
  456.         
  457.             if (Settings.CPrf.Define)
  458.             {
  459.                 if (c = strstr(buf, "#define"))
  460.                 {
  461.                     SetSName(structname, c + 7);
  462.  
  463.                     AddRefToList(list, 0, -1, totallines, structname);
  464.                 }
  465.             }
  466.  
  467.             if (Settings.CPrf.Typedef)
  468.             {
  469.                 if (c = strstr(buf, "typedef"))
  470.                 {
  471.                     while (*c != ';')
  472.                         c++;
  473.                     c--;
  474.  
  475.                     while (IsAlphaNum(*c))
  476.                         c--;
  477.                     c++;
  478.  
  479.                     SetSName(structname, c);
  480.                     AddRefToList(list, 0, -1, totallines, structname);
  481.                 }
  482.             }
  483.         }
  484.  
  485.         /* Write the final one */
  486.         if (namecopy[0])
  487.             AddRefToList(list, lastlastend, offset - lastlastend, lastlineoffset, namecopy);
  488.  
  489.         fclose(file);
  490.     }
  491.  
  492.     if ((!Settings.KeepEmpty) && IsListEmpty(&list->RefsList))
  493.     {
  494.         Remove(&list->node);
  495.         FreeVec(list);
  496.     }
  497. }
  498. ///
  499. /// EToList(STRPTR filename)
  500. void
  501. EToList(STRPTR filename)
  502. {
  503.     FILE *file;
  504.     struct FileEntry *list;
  505.     UBYTE buf[256], objectname[128], *c;
  506.     ULONG totallines = 0;
  507.  
  508.     if (!Settings.EPrf.Active)
  509.         return;
  510.     
  511.     if (!(list = AddFileToList(filename)))
  512.         return;
  513.  
  514.     if ((Settings.EPrf.Const || Settings.EPrf.Object || Settings.EPrf.Proc) && (file = fopen(filename, "r")))
  515.     {
  516.         while (fgets(buf, 256, file) != NULL)
  517.         {
  518.             ULONG offset = ftell(file) - strlen(buf);
  519.  
  520.             totallines++;
  521.  
  522.             if (Settings.EPrf.Object)
  523.             {
  524.                 if (c = strstr(buf, "OBJECT"))
  525.                 {
  526.                     c = SetSName(objectname, c + 6);
  527.                     
  528.                     totallines++;
  529.                     while (fgets(buf, 256, file) && (!strstr(buf, "ENDOBJECT")))
  530.                         totallines++;
  531.  
  532.                     AddRefToList(list, offset, ftell(file) - offset, 0, objectname);
  533.                 }
  534.  
  535.             }
  536.         
  537.             if (Settings.EPrf.Const)
  538.             {
  539.                 if ((strncmp(buf, "CONST", 5)) == 0)
  540.                 {
  541.                     do
  542.                     {
  543.                         SetSName(objectname, buf + 5);
  544.                         AddRefToList(list, offset, ftell(file) - offset, totallines, objectname);
  545.                         totallines++;
  546.                         if (!fgets(buf, 256, file))
  547.                             break;
  548.                     } while (strncmp(buf, "     ", 5) == 0);
  549.                 }
  550.             }
  551.  
  552.             if (Settings.EPrf.Proc)
  553.             {
  554.                 if ((strncmp(buf, "PROC", 4)) == 0)
  555.                 {
  556.                     SetSName(objectname, buf + 4);
  557.                     AddRefToList(list, offset, strlen(buf), 0, objectname);
  558.                 }
  559.             }
  560.         }
  561.  
  562.         fclose(file);
  563.     }
  564.  
  565.     if ((!Settings.KeepEmpty) && IsListEmpty(&list->RefsList))
  566.     {
  567.         Remove(&list->node);
  568.         FreeVec(list);
  569.     }
  570. }
  571. ///
  572. /// AsmToList(STRPTR filename)
  573. void
  574. AsmToList(STRPTR filename)
  575. {
  576.     FILE *file;
  577.     struct FileEntry *list;
  578.     UBYTE buf[256], name[128], *c;
  579.     ULONG totallines = 0;
  580.  
  581.     if (!Settings.AsmPrf.Active)
  582.         return;
  583.     
  584.     if (!(list = AddFileToList(filename)))
  585.         return;
  586.  
  587.     if ((Settings.AsmPrf.Equ || Settings.AsmPrf.Structure || Settings.AsmPrf.Macro) && (file = fopen(filename, "r")))
  588.     {
  589.         while (fgets(buf, 256, file))
  590.         {
  591.             ULONG offset = ftell(file) - strlen(buf);
  592.             STRPTR comment = buf;
  593.  
  594.             /* Check for comment and skip rest of line */
  595.             while (*comment)
  596.                 if ((*comment == ';') || (*comment == '*'))
  597.                     *comment = 0;
  598.                 else
  599.                     comment++;
  600.  
  601.             totallines++;
  602.  
  603.             if (Settings.AsmPrf.Equ)
  604.             {
  605.                 if ((c = strstr(buf, "EQU")) || (c = strstr(buf, "equ")))
  606.                 {
  607.                     c--;
  608.                     while (*c == ' ' || *c == '\t')
  609.                         c--;
  610.                     while (IsAlphaNum(*c))
  611.                         c--;
  612.  
  613.                     /* If the name starts with backslash (92) it's probably
  614.                      * part of a macro and we ignore.
  615.                      */
  616.                     if (*c != 92)
  617.                     {
  618.                         c++;
  619.                         SetSName(name, c);
  620.                         AddRefToList(list, 0, -1, totallines, name);
  621.                     }
  622.                 }
  623.  
  624.                 if (c = strstr(buf, "BITDEF"))
  625.                 {
  626.                     UBYTE mprefix[32], mname[32], mfinal[65];
  627.                     ULONG i;
  628.  
  629.                     c += 6;
  630.                     while (*c == ' ' || *c == '\t')
  631.                         c++;
  632.  
  633.                     for (i = 0; IsAlphaNum(*c); c++, i++)
  634.                         mprefix[i] = *c;
  635.                     mprefix[i] = 0;
  636.  
  637.                     while (!IsAlphaNum(*c))
  638.                         c++;
  639.  
  640.                     for (i = 0; IsAlphaNum(*c); c++, i++)
  641.                         mname[i] = *c;
  642.                     mname[i] = 0;
  643.  
  644.                     strcpy(mfinal, mprefix);
  645.                     strcat(mfinal, "B_");
  646.                     strcat(mfinal, mname);
  647.                     AddRefToList(list, 0, -1, totallines, mfinal);
  648.                     
  649.                     strcpy(mfinal, mprefix);
  650.                     strcat(mfinal, "F_");
  651.                     strcat(mfinal, mname);
  652.                     AddRefToList(list, 0, -1, totallines, mfinal);
  653.                 }
  654.             }
  655.             
  656.             if (Settings.AsmPrf.Structure)
  657.             {
  658.                 if (c = strstr(buf, "STRUCTURE"))
  659.                 {
  660.                     SetSName(name, c + 9);
  661.                     AddRefToList(list, 0, -1, totallines, name);
  662.                 }
  663.             }
  664.  
  665.             if (Settings.AsmPrf.Macro)
  666.             {
  667.                 if (c = strstr(buf, "MACRO"))
  668.                 {
  669.                     c--;
  670.                     while (*c == ' ' || *c == '\t')
  671.                         c--;
  672.                     if (*c == ':')
  673.                         c--;
  674.                     while (IsAlphaNum(*c))
  675.                         c--;
  676.                     c++;
  677.                     
  678.                     SetSName(name, c);
  679.                     AddRefToList(list, 0, -1, totallines, name);
  680.                 }
  681.             }
  682.  
  683.         }
  684.  
  685.         fclose(file);
  686.     }
  687.  
  688.     if ((!Settings.KeepEmpty) && IsListEmpty(&list->RefsList))
  689.     {
  690.         Remove(&list->node);
  691.         FreeVec(list);
  692.     }
  693.  
  694. }
  695. ///
  696.  
  697. /// SetSName(UBYTE *buf, UBYTE *ptr)
  698. UBYTE *
  699. SetSName(UBYTE *buf, UBYTE *ptr)
  700. {
  701.     while (*ptr == ' ' || *ptr == '\t')
  702.         ++ptr;
  703.     while (IsAlphaNum(*ptr))
  704.         *buf++ = *ptr++;
  705.     *buf = 0;
  706.     return(ptr);
  707. }
  708. ///
  709. /// IsAlphaNum(UBYTE c)
  710. BOOL
  711. IsAlphaNum(UBYTE c)
  712. {
  713.     if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
  714.         (c >= '0' && c <= '9') || (c == '_'))
  715.         return(1);
  716.  
  717.     return(0);
  718. }
  719. ///
  720.  
  721. /// AddFileToList(UBYTE *name)
  722. struct FileEntry *
  723. AddFileToList(UBYTE *name)
  724. {
  725.     struct FileEntry *entry;
  726.  
  727.     if (entry = AllocVec(sizeof(struct FileEntry) + strlen(name) + 1, NULL))
  728.     {
  729.         strcpy(entry->Name, name);
  730.         entry->node.ln_Name = entry->Name;
  731.         entry->node.ln_Type = 1;
  732.         NewList(&entry->RefsList);
  733.         
  734.         AddTail(&FileList, &entry->node);
  735.     }
  736.     return(entry);
  737. }
  738. ///
  739. /// AddRefToList(struct FileEntry *, LONG offset, length, gotoline, STRPTR name)
  740. struct RefsEntry *
  741. AddRefToList(struct FileEntry *fileentry, LONG offset, LONG length, WORD gotoline, STRPTR name)
  742. {
  743.     struct RefsEntry *entry;
  744.  
  745.     /* Do not add the reference if the name is empty (ie ""). */
  746.     if (!name[0])
  747.         return(NULL);
  748.  
  749.     if (entry = AllocVec(sizeof(struct RefsEntry) + strlen(name) + 1, NULL))
  750.     {
  751.         entry->Offset = offset;
  752.         entry->Length = length;
  753.         entry->Goto = gotoline;
  754.         strcpy(entry->Name, name);
  755.         entry->node.ln_Name = entry->Name;
  756.         entry->node.ln_Type = 2;
  757.  
  758.         AddTail(&fileentry->RefsList, &entry->node);
  759.     }
  760.     return(entry);
  761. }
  762. ///
  763.  
  764. /// ClearFileList()
  765. void
  766. ClearFileList(void)
  767. {
  768.     struct FileEntry *freefile;
  769.     struct RefsEntry *freelist;
  770.  
  771.     while (freefile = (struct FileEntry *)RemHead(&FileList))
  772.     {
  773.         while (freelist = (struct RefsEntry *)RemHead(&freefile->RefsList))
  774.             FreeVec(freelist);
  775.         FreeVec(freefile);
  776.     }
  777. }
  778. ///
  779.  
  780.